//校验学校编码 只能为数字
export function validateCode(rule, value, callback) {
    if (!value) {
        return callback(new Error('学校编码不能为空'))
    } else {
        const codeReg = /^[0-9]+$/
        const codeMax = /^\d{0,5}$/
        if (codeReg.test(value)) {
            if (codeMax.test(value)) {
                callback()
            } else {
                callback(new Error('学校编码不能大于5位'))
            }

        } else {
            callback(new Error('请输入正确的学校编码，只能是数字'))
        }
    }
}

//校验邮箱
export function validateEmail(rule, value, callback) {
    if (value) {
        const mailReg = /^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+(.[a-zA-Z0-9_-])+/
        if (mailReg.test(value)) {
            callback()
        } else {
            callback(new Error('请输入正确的邮箱格式'))
        }
    } else {
        callback()
    }
}

//校验英文
export function validateEng(rule, value, callback) {
    if (value) {
        const mailReg = /^[A-Za-z\-\&\(\)\Ⅰ\Ⅱ\Ⅲ\Ⅳ\Ⅴ\Ⅵ\Ⅶ\Ⅷ\Ⅸ\Ⅹ\s]+$/;
        if (mailReg.test(value)) {
            callback()
        } else {
            callback(new Error('请输入正确的英文名字'))
        }
    } else {
        callback()
    }
}

//校验姓名拼音
export function validateEngName(rule, value, callback) {
    if (value) {
        const EngNameReg = /^[A-Za-z \(\)\s]+$/
        if (EngNameReg.test(value)) {
            callback()
        } else {
            callback(new Error('请输入正确的姓名拼音'))
        }
    } else {
        callback()
    }
}

//校验手机号码
export function validateHanset(rule, value, callback) {
    if (value) {
        // const regs =/^[1][3,4,5,6,7,8,9][0-9]{9}$/;  //   /^1[3|4|5|6|7|8|9][0-9]\d{8}$/
        const regs = /^1\d{10}$/
        if (regs.test(value)) {
            callback()
        } else {
            return callback(new Error('请输入正确的手机号'))
        }
    } else {
        callback()
    }
}

//校验座机电话
export function validatePhone(rule, value, callback) {
    if (value) {
        //const reg = /^1[3|4|5|7|8][0-9]\d{8}$/
        // const regs = /^([0-9]{3,4}-)?[0-9]{7,8}$/; /^((0\d{2,3}-\d{7,8}))$/;
        const regs = /^([0-9]{3,4}-)?[0-9]{7,8}$/
        // console.log(regss.test(value));
        if (regs.test(value)) {
            callback()
        } else {
            return callback(new Error('请输入正确的座机号'))
        }
    } else {
        callback()
    }
}

//校验家庭电话 手机或者座机
export function validateFamilyPhone(rule, value, callback) {
    if (value) {
        const isPhone = /^([0-9]{3,4}-)?[0-9]{7,8}$/;
        const isMob = /^((\+?86)|(\+86))?(13[0123456789][0-9]{8}|15[0123456789][0-9]{8}|17[0123456789][0-9]{8}|18[0123456789][0-9]{8}|147[0-9]{8}|1349[0-9]{7})$/;
        // console.log(regss.test(value));
        if (isPhone.test(value) || isMob.test(value)) {
            callback()
        } else {
            return callback(new Error('请输入正确的手机或者座机电话'))
        }
    } else {
        callback()
    }
}

// 校验只能为中文
export function validateChinese(rule, value, callback) {
    if (value) {
        const chineseReg = /^[\u4E00-\u9FA5]+$/
        if (chineseReg.test(value)) {
            callback()
        } else {
            callback(new Error('请输入简介，只能为中文'))
        }
    } else {
        callback()
    }
}

// 校验名称既能为中文也可以为英文
export function validateName(rule, value, callback) {
    if (value) {
        const chineseReg = /^[\u4E00-\u9FA5]+$/
        const engLish = /^[A-Za-z]+$/
        if (chineseReg.test(value) || engLish.test(value)) {
            callback()
        } else {
            callback(new Error('请输入正确的中文或者英文名称'))
        }
    } else {
        callback()
    }
}

// 校验负责人既能为中文也可以为英文
export function validateChargeperson(rule, value, callback) {
    if (value) {
        const chineseReg = /^[\u4E00-\u9FA5]+$/
        const engLish = /^[A-Za-z]+$/
        if (chineseReg.test(value) || engLish.test(value)) {
            callback()
        } else {
            callback(new Error('请输入正确的负责人（中英文都可以）'))
        }
    } else {
        callback()
    }
}

//校验学校名称不能为空
export function validateXXMC(rule, value, callback) {
    if (!value) {
        return callback(new Error('案例名称不能为空'))
    } else {
        const chineseReg = /^[\u4E00-\u9FA5]+$/
        if (chineseReg.test(value)) {
            callback()
        } else {
            callback(new Error('请输入正确的案例名称，只能是汉字'))
        }
    }
}

//校验中英文数字和下划线都可以
export function validateZYS(rule, value, callback) {
    if (value) {
        //const postReg =/^[\u4e00-\u9fa5_a-zA-Z0-9_]{4,10}+$/
        const Reg = /^[\u4e00-\u9fa5a-zA-Z0-9]+$/
        if (Reg.test(value)) {
            callback()
        } else {
            callback(new Error('请输入正确的名称'))
        }
    } else {
        callback()
    }
}

// 校验邮政编码
export function validatePostCode(rule, value, callback) {
    if (value) {
        const postReg = /^[1-9]\d{5}$/
        if (postReg.test(value)) {
            callback()
        } else {
            callback(new Error('请输入正确的邮政编码'))
        }
    } else {
        callback()
    }
}

// 数字
export function validateNum(rule, value, callback) {
    if (value) {
        const numReg = /^[\d]+$/
        if (numReg.test(value)) {
            callback()
        } else {
            callback(new Error('请输入数字'))
        }
    } else {
        callback()
    }
}

//数字和小数点
export function validateNumDot(rule, value, callback) {
    if (value) {
        const numReg = /^\d+$|^\d+\.\d+$/g
        if (numReg.test(value)) {
            callback()
        } else {
            callback(new Error('请输入数字或小数点'))
        }
    } else {
        callback()
    }
}

// 组织机构代码
export function validateOrganization(rule, value, callback) {
    if (value) {
        const orgReg = /^[A-Za-z0-9]\w{14}$/g
        if (orgReg.test(value)) {
            callback()
        } else {
            callback(new Error('请输入组织机构代码'))
        }
    } else {
        callback()
    }

}

// 传真
export function validateFax(rule, value, callback) {
    if (value) {
        const faxReg = /^(\d{3,4}-)?\d{7,8}$/
        if (faxReg.test(value)) {
            callback()
        } else {
            callback(new Error('请输入正确的传真'))
        }
    } else {
        callback()
    }
}

// 主页地址
export function validateHome(rule, value, callback) {
    if (value) {
        const homeReg = /^(?:http(s)?:\/\/)?[\w.-]+(?:\.[\w\.-]+)+[\w\-\._~:/?#[\]@!\$&'\*\+,;=.]+$/
        if (homeReg.test(value)) {
            callback()
        } else {
            return callback(new Error('请输入正确的主页地址'))
        }
    } else {
        callback()
    }
}

// 学分 小数，且保留最多三位小数
export function validateXf(rule, value, callback) {
    if (!value) {
        return callback(new Error('学分不能为空'))
    } else {
        const numReg = /^[0-9]+\.[0-9]{0,3}$/
        if (numReg.test(value)) {
            callback()
        } else {
            callback(new Error('请输入小数，且小数点后最多三位'))
        }
    }
}

// 数字格式  小数点后一位
export function validateOneNum(rule, value, callback) {
    if (value) {
        const numReg = /^\d+(\.\d+)?$/
        const numOneReg = /^\d*\.{0,1}\d{0,1}$/
        if (numReg.test(value)) {
            if (numOneReg.test(value)) {
                callback()
            } else {
                callback(new Error('小数点后最多1位'))
            }
        } else {
            callback(new Error('请输入数字'))
        }
    }
    callback()
}

// 数字格式  小数点后两位
export function validateTwoNum(rule, value, callback) {
    if (value) {
        const numReg = /^\d+(\.\d+)?$/
        const numTwoReg = /^\d*\.{0,2}\d{0,2}$/
        if (numReg.test(value)) {
            if (numTwoReg.test(value)) {
                callback()
            } else {
                callback(new Error('小数点后最多2位'))
            }
        } else {
            callback(new Error('请输入数字'))
        }
    }
    callback()
}

// 数字格式  小数点后两位  	小数点前保留五位
export function validateTwoNumThree(rule, value, callback) {
    if (value) {
        if (Number(value) > 10000) {// 校验value值不能大于10000
            console.log(Number(value))
            callback(new Error('数值过大，请重新输入'))
        }

        const numReg = /^\d+(\.\d+)?$/
        const numTwoReg = /^\d*\.{0,2}\d{0,2}$/
        if (numReg.test(value)) {
            if (numTwoReg.test(value)) {
                callback()
            } else {
                callback(new Error('小数点后最多2位'))
            }
        } else {
            callback(new Error('请输入数字'))
        }
    }

    callback()
}

// 数字格式  小数点后三位
export function validateThreeNum(rule, value, callback) {
    if (value) {
        const numReg = /^\d+(\.\d+)?$/
        const numTwoReg = /^\d*\.{0,3}\d{0,3}$/
        if (numReg.test(value)) {
            if (numTwoReg.test(value)) {
                callback()
            } else {
                callback(new Error('小数点后最多3位'))
            }
        } else {
            callback(new Error('请输入数字'))
        }
    }
    callback()
    // if (!value) {
    // 	return callback(new Error('字段不能为空'))
    // } else {
    // 	const numReg = /^\d+(\.\d+)?$/
    // 	const numTwoReg = /^\d*\.{0,3}\d{0,3}$/
    // 	if (numReg.test(value)) {
    // 		if (numTwoReg.test(value)) {
    // 				callback()
    // 		} else {
    // 			callback(new Error('小数点后最多3位'))
    // 		}
    // 	} else {
    // 		callback(new Error('请输入数字'))
    // 	}
    // }
}

//校验年份必须为4位数字
export function validateNF(rule, value, callback) {
    if (value) {
        const NFReg = /^\d{4}$/
        if (NFReg.test(value)) {
            callback()
        } else {
            callback(new Error('请输入4位数字'))
        }
    } else {
        callback()
    }
}

//校验年份必须为4位数字
export function validateXQ(rule, value, callback) {
    if (value) {
        const NFReg = /^\d{5}$/
        if (NFReg.test(value)) {
            callback()
        } else {
            callback(new Error('请输入5位数字'))
        }
    } else {
        callback()
    }
}

//校验分数最大值
export function validateMaxNumber(rule, value, callback) {
    if (parseInt(value) <= 200) {
        callback()
    } else {
        callback(new Error('分数不能大于200'))
    }

}

//校验正整数
export function validateInteger(rule, value, callback) {
    if (value) {
        const integerReg = /^[+]{0,1}(\d+)$/
        if (integerReg.test(value)) {
            callback()
        } else {
            callback(new Error('请输入正确的整数'))
        }
    } else {
        callback()
    }
}

//校验整数
export function validateroundNumber(rule, value, callback) {
    if (value) {
        const numReg = /^[1-9]\d*$/
        if (numReg.test(value)) {
            callback()
        } else {
            callback(new Error('请输入正确的整数'))
        }
    } else {
        callback()
    }
}

//校验身份证号
export function validateCard(rule, value, callback) {
    if (value) {
        let cardBoolean = IdCardValidate(value);
        // const cardReg =/(^\d{18}$)|(^\d{17}(\d|X|x)$)/
        // if (cardReg.test(value)) {
        if (cardBoolean) {
            callback()
        } else {
            callback(new Error('请输入正确的身份证号'))
        }
    } else {
        callback()
    }
}
//校验身份证号新 表格内编辑使用
export function validateCardNew({ cellValue }) {
    return new Promise((resolve, reject)=>{
        if (cellValue) {
            let cardBoolean = IdCardValidate(cellValue);
            if (cardBoolean) {
                resolve()
            } else {
                reject(new Error('请输入正确的身份证号'))
            }
        } else {
            reject(new Error('请输入身份证号'))
        }
    })
}
//身份证：身份证校验
export function CardValidate(code) {
    console.log(code)
    var tip = "";
    if (code != "") {
        var city = {
            11: "北京",
            12: "天津",
            13: "河北",
            14: "山西",
            15: "内蒙古",
            21: "辽宁",
            22: "吉林",
            23: "黑龙江 ",
            31: "上海",
            32: "江苏",
            33: "浙江",
            34: "安徽",
            35: "福建",
            36: "江西",
            37: "山东",
            41: "河南",
            42: "湖北 ",
            43: "湖南",
            44: "广东",
            45: "广西",
            46: "海南",
            50: "重庆",
            51: "四川",
            52: "贵州",
            53: "云南",
            54: "西藏 ",
            61: "陕西",
            62: "甘肃",
            63: "青海",
            64: "宁夏",
            65: "新疆",
            71: "台湾",
            81: "香港",
            82: "澳门",
            91: "国外 "
        };

        var pass = true;

        //是否为空
        if (code === '') {
            tip = "请输入身份证号，身份证号不能为空";
            pass = false;
        }
        //校验长度，类型
        else if (isCardNo(code) === false) {
            tip = "您输入的身份证号码不正确，请重新输入";
            pass = false;
        }
        //检查省份
        else if (checkProvince(code, city) === false) {
            tip = "您输入的身份证号码不正确,请重新输入";
            pass = false;
        }
        //校验生日
        else if (checkBirthday(code) === false) {
            tip = "您输入的身份证号码生日不正确,请重新输入";
            pass = false;
        } else {
            //18位身份证需要验证最后一位校验位
            if (code.length == 18) {
                var Wi = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2, 1]; // 加权因子
                var ValideCode = [1, 0, 10, 9, 8, 7, 6, 5, 4, 3, 2];
                var sum = 0; // 声明加权求和变量
                code = code.split('');
                console.log(code[17])

                if (code[17].toLowerCase() == 'x') {
                    code[17] = 10; // 将最后位为x的验证码替换为10方便后续操作
                }
                for (var i = 0; i < 17; i++) {
                    sum += Wi[i] * code[i]; // 加权求和
                }
                var valCodePosition = sum % 11; // 得到验证码所位置
                if (code[17] == ValideCode[valCodePosition]) {
                    pass = true;
                } else {
                    pass = false;
                }
                // code = code.split('');
                // //∑(ai×Wi)(mod 11)
                // //加权因子
                // var factor = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];
                // //校验位
                // var parity = [1, 0, 'X','x', 9, 8, 7, 6, 5, 4, 3, 2];
                // var sum = 0;
                // var ai = 0;
                // var wi = 0;
                // for (var i = 0; i < 17; i++) {
                //     ai = code[i];
                //     wi = factor[i];
                //     sum += ai * wi;
                // }
                // console.log('sum',sum)
                // var last = parity[sum % 11];
                // console.log('parity[sum % 11] ',parity[sum % 11] )
                // if (parity[sum % 11] != code[17]) {
                //     tip = "身份证格式错误";
                //     pass = false;
                // }
            }
        }
        return pass;
    }
}

//身份证：身份证校验
function IdCardValidate(code) {
    var tip = "";
    if (code != "") {
        var city = {
            11: "北京",
            12: "天津",
            13: "河北",
            14: "山西",
            15: "内蒙古",
            21: "辽宁",
            22: "吉林",
            23: "黑龙江 ",
            31: "上海",
            32: "江苏",
            33: "浙江",
            34: "安徽",
            35: "福建",
            36: "江西",
            37: "山东",
            41: "河南",
            42: "湖北 ",
            43: "湖南",
            44: "广东",
            45: "广西",
            46: "海南",
            50: "重庆",
            51: "四川",
            52: "贵州",
            53: "云南",
            54: "西藏 ",
            61: "陕西",
            62: "甘肃",
            63: "青海",
            64: "宁夏",
            65: "新疆",
            71: "台湾",
            81: "香港",
            82: "澳门",
            91: "国外 "
        };

        var pass = true;

        //是否为空
        if (code === '') {
            tip = "请输入身份证号，身份证号不能为空";
            pass = false;
        }
        //校验长度，类型
        else if (isCardNo(code) === false) {
            tip = "您输入的身份证号码不正确，请重新输入";
            pass = false;
        }
        //检查省份
        else if (checkProvince(code, city) === false) {
            tip = "您输入的身份证号码不正确,请重新输入";
            pass = false;
        }
        //校验生日
        else if (checkBirthday(code) === false) {
            tip = "您输入的身份证号码生日不正确,请重新输入";
            pass = false;
        } else {
            //18位身份证需要验证最后一位校验位
            if (code.length == 18) {
                code = code.split('');
                //∑(ai×Wi)(mod 11)
                //加权因子
                var factor = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2, 1];
                //校验位
                var parity = [1, 0, 10, 9, 8, 7, 6, 5, 4, 3, 2];
                var sum = 0;
                var ai = 0;
                var wi = 0;
                if (code[17].toLowerCase() == 'x' || code[17].toLowerCase() == 'X') {
                    code[17] = 10; // 将最后位为x的验证码替换为10方便后续操作
                }
                for (var i = 0; i < 17; i++) {
                    ai = code[i];
                    wi = factor[i];
                    sum += ai * wi;
                }
                var last = parity[sum % 11];
                if (parity[sum % 11] != code[17]) {
                    tip = "身份证格式错误";
                    pass = false;
                }
            }
        }
        return pass;
    }
}

//身份证：检查身份证号码是否符合规范，包括长度，类型
function isCardNo(card) {
    //身份证号码为15位或者18位，15位时全为数字，18位前17位为数字，最后一位是校验位，可能为数字或字符X
    var reg = /(^\d{15}$)|(^\d{17}(\d|X)$)|(^\d{17}(\d|x)$)/;
    if (reg.test(card) === false) {
        return false;
    }
    return true;
};

//身份证：取身份证前两位,校验省份
function checkProvince(card, city) {
    var province = card.substr(0, 2);
    if (city[province] == undefined) {
        return false;
    }
    return true;
};

//身份证：检查生日是否正确
function checkBirthday(card) {
    var len = card.length;
    //身份证15位时，次序为省（3位）市（3位）年（2位）月（2位）日（2位）校验位（3位），皆为数字
    if (len == '15') {
        var re_fifteen = /^(\d{6})(\d{2})(\d{2})(\d{2})(\d{3})$/;
        var arr_data = card.match(re_fifteen);
        var year = arr_data[2];
        var month = arr_data[3];
        var day = arr_data[4];
        var birthday = new Date('19' + year + '/' + month + '/' + day);
        return verifyBirthday('19' + year, month, day, birthday);
    }
    //身份证18位时，次序为省（3位）市（3位）年（4位）月（2位）日（2位）校验位（4位），校验位末尾可能为X
    if (len == '18') {
        var re_eighteen = /^(\d{6})(\d{4})(\d{2})(\d{2})(\d{3})([0-9]|X|x)$/;
        var arr_data = card.match(re_eighteen);
        var year = arr_data[2];
        var month = arr_data[3];
        var day = arr_data[4];
        var birthday = new Date(year + '/' + month + '/' + day);
        return verifyBirthday(year, month, day, birthday);
    }
    return false;
};

//身份证：校验日期
function verifyBirthday(year, month, day, birthday) {
    var now = new Date();
    var now_year = now.getFullYear();
    //年月日是否合理
    if (birthday.getFullYear() == year && (birthday.getMonth() + 1) == month && birthday.getDate() == day) {
        //判断年份的范围（3岁到100岁之间)
        var time = now_year - year;
        if (time >= 3 && time <= 100) {
            return true;
        }
        return false;
    }
    return false;
};

/**
 * 判断身份证号码为18位时最后的验证位是否正确
 * @param a_idCard 身份证号码数组
 * @return
 */
function isTrueValidateCodeBy18IdCard(a_idCard) {
    let By18Val = a_idCard[17].toLowerCase(); // 获取第十八位值
    const numReg = /^[1-9]\d*$/
    let numVal = false; // 校验第十八位是否为整数
    if (numReg.test(Number(By18Val))) {
        numVal = true
    } else {
        numVal = false
    }
    if (By18Val == 'x' || By18Val == 'X' || numVal) {
        return true
    } else {
        return false
    }
}

/**
 * 验证身份证号码前两位，省级编码的准确性
 * @param AddressNum
 * @constructor
 */
function IdCardValidateAddress(AddressNum) {
    var city = {
        11: "北京",
        12: "天津",
        13: "河北",
        14: "山西",
        15: "内蒙古",
        21: "辽宁",
        22: "吉林",
        23: "黑龙江 ",
        31: "上海",
        32: "江苏",
        33: "浙江",
        34: "安徽",
        35: "福建",
        36: "江西",
        37: "山东",
        41: "河南",
        42: "湖北 ",
        43: "湖南",
        44: "广东",
        45: "广西",
        46: "海南",
        50: "重庆",
        51: "四川",
        52: "贵州",
        53: "云南",
        54: "西藏 ",
        61: "陕西",
        62: "甘肃",
        63: "青海",
        64: "宁夏",
        65: "新疆",
        71: "台湾",
        81: "香港",
        82: "澳门",
        91: "国外 "
    };
    if (city[AddressNum.substr(0, 2)]) {
        return true
    } else {
        return false
    }
}

/**
 * 验证18位数身份证号码中的生日是否是有效生日
 * @param idCard 18位书身份证字符串
 * @return
 */
function isValidityBrithBy18IdCard(idCard18) {
    var year = idCard18.substring(6, 10);
    var month = idCard18.substring(10, 12);
    var day = idCard18.substring(12, 14);
    var temp_date = new Date(year, parseFloat(month) - 1, parseFloat(day));
    // 这里用getFullYear()获取年份，避免千年虫问题
    if (temp_date.getFullYear() != parseFloat(year)
            || temp_date.getMonth() != parseFloat(month) - 1
            || temp_date.getDate() != parseFloat(day)) {
        return false;
    } else {
        return true;
    }
}

/**
 * 验证15位数身份证号码中的生日是否是有效生日
 * @param idCard15 15位书身份证字符串
 * @return
 */
function isValidityBrithBy15IdCard(idCard15) {
    var year = idCard15.substring(6, 8);
    var month = idCard15.substring(8, 10);
    var day = idCard15.substring(10, 12);
    var temp_date = new Date(year, parseFloat(month) - 1, parseFloat(day));
    // 对于老身份证中的你年龄则不需考虑千年虫问题而使用getYear()方法
    if (temp_date.getYear() != parseFloat(year)
            || temp_date.getMonth() != parseFloat(month) - 1
            || temp_date.getDate() != parseFloat(day)) {
        return false;
    } else {
        return true;
    }
}

/**
 * 去掉字符串头尾空格
 * @param str
 * @returns {*}
 */
function trim(str) {
    return str.replace(/(^\s*)|(\s*$)/g, "");
}

export default {
    validateCode,
    validateEmail,
    validateEng,
    validatePhone,
    validateChinese,
    validatePostCode,
    validateNum,
    validateNumDot,
    validateZYS,
    validateOrganization,
    validateFax,
    validateHome,
    validateXXMC,
    validateXf,
    validateOneNum,
    validateMaxNumber,
    validateTwoNum,
    validateTwoNumThree,
    validateThreeNum,
    validateInteger,
    validateNF,
    validateXQ,
    validateroundNumber,
    validateEngName,
    validateCard,
    validateHanset,
    validateFamilyPhone,
    validateName,
    validateChargeperson
}
